let _this;
export default _this = {
    check: {
        /**
         * 判断小数位数是否超过了指定位数
         * 例: 1.111 返回 true 1.11 返回 false
         * @param val 小数
         * @param digits 位数
         * */
        isDecimalOutBounds(val, digits) {
            let s = val.toString();
            /* 不是小数或数字直接返回true */
            if (!this.isNumber(s) || !s.includes(".")) {
                return false
            }
            return s.length - 1 - s.indexOf('.') > digits
        },
        isNumber(val) {
            if (this.isNull(val)) {
                return false;
            }
            val = val.toString();
            let regPos = /^\d+(\.\d+)?$/;
            let regNeg = /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/;
            return regPos.test(val) || regNeg.test(val);
        },
        isBankNumber(val) {
            let reg = /^([1-9]{1})(\d{14}|\d{18})$/;
            return reg.test(val)
        },
        /**
         * 传入时间戳 , 判断是否在当前时间之后
         * */
        isAfter(timestamp) {
            return new Date().getTime() > timestamp;
        },

        /**
         * 传入时间戳 , 判断是否在当前时间之前
         * */
        isBefore(timestamp) {
            return new Date().getTime() < timestamp;
        },

        /**
         * 数组中是否有元素为null
         * */
        arrItemIsNull(arr) {
            if (!Array.isArray(arr)) {
                console.log("arrItemIsNull 传入了非 Array 类型 转调 isNull param: ", arr)
                return this.isNull(arr);
            }
            return arr.some(e => this.isNull(e))
        },
        /**
         * 判断文件大小是否超标
         * 文件大小单位为 字节
         * @param arr 文件list
         * @param size 文件大小 单位 M
         * */
        fileSizeOutBounds(arr, size) {
            size *= 1000000
            return arr.some(e => {
                return e.size > size
            });
        }
    },

    html: {
        /**
         * 距离文本
         * */
        distanceText(km = 0) {
            if (isNull(km) || isNaN(km)) {
                return '计算距离失败';
            }
            km = Number(km);
            let text = km > 1 ? km + " km" : km * 1000 + " m"
            if (km <= 0.1) {
                text = '100 m 以内'
            }
            return '距离 ' + text;
        }
    },
    /**
     * 数组转字符串 ,
     * arr 数组
     * separator 元素分割符号
     * */
    arrToString(arr, separator) {
        if (typeof arr === "string") {
            return arr;
        }
        if (!Array.isArray(arr)) {
            throw new Error(' file : service.js | function : arrToString | msg : 非数组,非字符串 | value : ' + arr)
        }
        if (arr.length === 0) {
            return '';
        } else if (arr.length === 1) {
            return arr[0] + '';
        }
        let result = '';
        arr.forEach(e => {
            result += e + separator
        })
        return result.substring(0, result.length - 1)
    },

    /**
     * 用于获取响应中的多个参数 ,防止解析参数的过程中出错导致页面整体加载失败
     * task 需要执行的任务
     * errMsg 错误信息
     * errorFields 存储解析错误的字段数组
     * 执行任务
     * */
    executeTask(task = function () {
    }, errorFields = [], errMsg = '') {
        try {
            task();
        } catch (e) {
            console.log(" executeTask - err : ", e)
            errorFields.push(errMsg)
        }
    },
}

export function isNull(v) {
    let result = typeof v === "undefined" || v === null || v === ''
    if (typeof v === "string") {
        result = v.trim() === ''
    }
    if (Array.isArray(v)) {
        result = v.length === 0
    }
    return result
}

export function isValidJSONString(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return true;
}

/**
 * 如果传入值为空 返回指定字符串
 * */
export function isNullToStr(v, str = '丢失') {
    if (isNull(v)) {
        return str
    }
    return v;
}

/**
 * 将数字转为百分比格式
 * */
export function formatPercentage(num, decimalPlaces = 2) {
    if (isNull(num)){
        return "-";
    }
    const percentage = (num * 100).toFixed(decimalPlaces);
    const formattedPercentage = percentage.toLocaleString() + '%';
    return formattedPercentage;
}

/**
 * 计算两个 date 之间相差的天数
 * */
export function daysBetween(date1, date2) {
    const ONE_DAY = 1000 * 60 * 60 * 24; // 1 day in milliseconds
    const date1Timestamp = new Date(date1).getTime();
    const date2Timestamp = new Date(date2).getTime();
    const timeDiff = Math.abs(date2Timestamp - date1Timestamp);
    const diffDays = Math.ceil(timeDiff / ONE_DAY);
    return diffDays;
}

export function getStrCharLen(v){
    const chineseCharNum = v.match(/[\u4e00-\u9fa5]/g)?.length || 0;
    const englishCharNum = v.length - chineseCharNum;
    return englishCharNum + chineseCharNum * 2;
}

/**
 * 构造树型结构数据
 * @param {*} data 数据源
 * @param {*} id id字段 默认 'id'
 * @param {*} parentId 父节点字段 默认 'parentId'
 * @param {*} children 孩子节点字段 默认 'children'
 * @param {*} rootId 根Id 默认 0
 */
export function handleTree(data, id, parentId, children, rootId) {
    id = id || 'id'
    parentId = parentId || 'parentId'
    children = children || 'children'
    rootId = rootId || Math.min.apply(Math, data.map(item => {
        return item[parentId]
    })) || 0
    //对源数据深度克隆
    const cloneData = JSON.parse(JSON.stringify(data))
    //循环所有项
    const treeData = cloneData.filter(father => {
        let branchArr = cloneData.filter(child => {
            //返回每一项的子级数组
            return father[id] === child[parentId]
        });
        branchArr.length > 0 ? father.children = branchArr : '';
        //返回第一层
        return father[parentId] === rootId;
    });
    return treeData !== '' ? treeData : data;
}

export function copy(v) {
    return JSON.parse(JSON.stringify(v))
}

export function parseDate1(date){
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    return `${year}-${month}-${day}`
}

export function globalLoading(vm,lock=true,text="Loading...",spinner='el-icon-loading',background="rgba(0, 0, 0, 0.7)"){
    return vm.$loading({
        lock: lock,
        text: text,
        spinner: spinner,
        background: background
    });
}

export function gotoLink(link){
    window.open(link, '_blank');
}

export function deepEqual(value1, value2) {
    if (value1 === value2) {
        return true; // 基本类型或引用相同的对象，直接相等
    }

    if (typeof value1 !== typeof value2) {
        return false; // 类型不同，直接不相等
    }

    if (typeof value1 !== "object" || typeof value2 !== "object" || value1 === null || value2 === null) {
        return false; // 不是对象或其中一个是null，直接不相等
    }

    // 获取对象的属性名数组
    const keys1 = Object.keys(value1);
    const keys2 = Object.keys(value2);

    // 属性数量不同，直接不相等
    if (keys1.length !== keys2.length) {
        return false;
    }

    // 比较属性和值
    for (const key of keys1) {
        if (!deepEqual(value1[key], value2[key])) {
            return false; // 递归比较属性值
        }
    }

    return true; // 所有属性和值都匹配
}

export function deepClone(obj) {
    if (obj === null || typeof obj !== 'object') {
        return obj;
    }

    if (Array.isArray(obj)) {
        return obj.map(item => deepClone(item));
    }

    const cloned = {};
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            cloned[key] = deepClone(obj[key]);
        }
    }

    return cloned;
}